"""
本地测试应用，使用模拟服务
"""
import os
from flask import Flask, jsonify, request
from flask_cors import CORS
from services.mock_service import MockRedisService, MockDifyService, MockDatabaseRepository
from utils.logger import setup_logger

# 设置日志
logger = setup_logger()

# 创建模拟服务实例
mock_redis_service = MockRedisService()
mock_dify_service = MockDifyService()
mock_db_repository = MockDatabaseRepository()

def create_app():
    """
    创建用于测试的Flask应用
    """
    app = Flask(__name__)
    
    # 配置CORS
    CORS(app, resources={r"/api/*": {"origins": "*"}})
    
    # 数据源API路由
    @app.route('/api/data-source/get', methods=['POST'])
    def get_data_sources():
        """
        获取数据源信息API
        """
        try:
            # 获取请求数据
            request_data = request.get_json()
            logger.info(f"接收到获取数据源请求: {request_data}")
            
            # 验证请求参数
            if not request_data or 'query' not in request_data:
                logger.warning("请求参数无效，缺少query字段")
                return jsonify({
                    'success': False,
                    'message': '请求参数无效，缺少query字段'
                }), 400
            
            # 获取查询文本
            query_text = request_data['query']
            
            # 检查模拟Redis缓存
            redis_key = f"data_source:{query_text}"
            cached_data = mock_redis_service.get_data(redis_key)
            
            if cached_data:
                logger.info(f"从模拟Redis缓存获取到数据源信息: {redis_key}")
                return jsonify({
                    'success': True,
                    'message': '从缓存获取数据源成功',
                    'data': cached_data,
                    'from_cache': True
                }), 200
            
            # 从模拟Dify API获取数据
            logger.info(f"缓存未命中，从模拟Dify API获取数据源: {query_text}")
            dify_result = mock_dify_service.get_data_sources(query_text)
            
            if not dify_result:
                logger.error("从模拟Dify API获取数据源失败")
                return jsonify({
                    'success': False,
                    'message': '从Dify API获取数据源失败',
                    'data': None
                }), 500
            
            # 保存到模拟数据库
            task_id = mock_db_repository.save_task(dify_result['task_data'])
            
            if 'retrieval_conditions' in dify_result and dify_result['retrieval_conditions']:
                mock_db_repository.save_retrieval_conditions(dify_result['retrieval_conditions'])
            
            if 'scraping_strategies' in dify_result and dify_result['scraping_strategies']:
                mock_db_repository.save_scraping_strategies(dify_result['scraping_strategies'])
            
            if 'authorization_info' in dify_result and dify_result['authorization_info']:
                mock_db_repository.save_authorization_info(dify_result['authorization_info'])
            
            # 缓存到模拟Redis
            mock_redis_service.set_data(redis_key, dify_result)
            
            return jsonify({
                'success': True,
                'message': '获取数据源成功',
                'data': dify_result,
                'from_cache': False
            }), 200
            
        except Exception as e:
            logger.error(f"处理数据源请求时发生错误: {e}")
            return jsonify({
                'success': False,
                'message': f'处理请求时发生错误: {str(e)}'
            }), 500
    
    @app.route('/api/data-source/health', methods=['GET'])
    def health_check():
        """健康检查接口"""
        return jsonify({
            'status': 'ok',
            'service': 'data-source-api-test'
        }), 200
    
    @app.route('/')
    def home():
        return jsonify({
            'status': 'ok',
            'message': '数据源测试服务已启动'
        }), 200
    
    logger.info("测试Flask应用创建完成")
    return app

if __name__ == '__main__':
    app = create_app()
    # 获取端口，默认为5000
    port = int(os.environ.get('PORT', 5000))
    logger.info(f"测试应用将在端口 {port} 上启动")
    app.run(host='0.0.0.0', port=port, debug=True) 